home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gdevos2p.c < prev    next >
C/C++ Source or Header  |  1996-09-07  |  20KB  |  702 lines
  1. /* Copyright (C) 1995, 1996 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gdevos2p.c */
  20. /*
  21.  * OS/2 printer device
  22.  * by Russell Lang.
  23.  * Derived from mswinpr2 device by Russell Lang and
  24.  * L. Peter Deutsch, Aladdin Enterprises.
  25.  */
  26.  
  27. /* This device works when GS is a DLL loaded by a PM program */
  28. /* It does not work when GS is a text mode EXE */
  29.  
  30. /* This driver uses the printer default size and resolution and
  31.  * ignores page size and resolution set using -gWIDTHxHEIGHT and
  32.  * -rXxY.  You must still set the correct PageSize to get the
  33.  * correct clipping path.  If you don't specify a value for
  34.  * -dBitsPerPixel, the depth will be obtained from the printer
  35.  * device context.
  36.  */
  37.  
  38. #define INCL_DOS
  39. #define INCL_DOSERRORS
  40. #define INCL_DEV
  41. #define INCL_GPIBITMAPS
  42. #define INCL_SPL
  43. #define INCL_SPLDOSPRINT
  44. #define INCL_SPLERRORS
  45.  
  46. #include <os2.h>
  47.  
  48. #include "gdevprn.h"
  49. #include "gdevpccm.h"
  50. #include "gp.h"
  51.  
  52. extern HWND hwndtext;        /* in gp_os2.h */
  53. extern const char *gs_product;
  54.  
  55. typedef struct tagOS2QL {
  56.     PRQINFO3    *prq;    /* queue list */
  57.     ULONG    len;    /* bytes in queue list (for gs_free) */
  58.     int        defqueue; /* default queue */
  59.     int     nqueues;  /* number of queues */
  60. } OS2QL;
  61.  
  62. #ifndef NERR_BufTooSmall
  63. #define NERR_BufTooSmall 2123    /* For SplEnumQueue */
  64. #endif
  65.  
  66. /* Make sure we cast to the correct structure type. */
  67. typedef struct gx_device_os2prn_s gx_device_os2prn;
  68. #undef opdev
  69. #define opdev ((gx_device_os2prn *)dev)
  70.  
  71. /* Device procedures */
  72.  
  73. /* See gxdevice.h for the definitions of the procedures. */
  74. private dev_proc_open_device(os2prn_open);
  75. private dev_proc_close_device(os2prn_close);
  76. private dev_proc_print_page(os2prn_print_page);
  77. private dev_proc_map_rgb_color(os2prn_map_rgb_color);
  78. private dev_proc_map_color_rgb(os2prn_map_color_rgb);
  79. private dev_proc_put_params(os2prn_put_params);
  80. private dev_proc_get_params(os2prn_get_params);
  81.  
  82. private void os2prn_set_bpp(gx_device *dev, int depth);
  83. private int os2prn_get_queue_list(OS2QL *ql);
  84. private void os2prn_free_queue_list(OS2QL *ql);
  85. int os2prn_get_printer(OS2QL *ql);
  86.  
  87. private gx_device_procs os2prn_procs =
  88.   prn_color_params_procs(os2prn_open, gdev_prn_output_page, os2prn_close,
  89.    os2prn_map_rgb_color, os2prn_map_color_rgb, 
  90.    os2prn_get_params, os2prn_put_params);
  91.  
  92.  
  93. /* The device descriptor */
  94. struct gx_device_os2prn_s {
  95.     gx_device_common;
  96.     gx_prn_device_common;
  97.     HAB hab;
  98.     HDC hdc;
  99.     HPS hps;
  100.     char queue_name[256];    /* OS/2 printer queue name */
  101.     int newframe;        /* false before first page */
  102.     OS2QL ql;
  103.     int clipbox[4];        /* llx, lly, urx, ury in pixels */
  104.     HDC hdcMem;
  105.     HPS hpsMem;
  106. };
  107.  
  108. gx_device_os2prn far_data gs_os2prn_device = {
  109.   prn_device_std_body(gx_device_os2prn, os2prn_procs, "os2prn",
  110.   DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS, 72, 72,
  111.   0, 0, 0, 0,
  112.   0, os2prn_print_page), /* depth = 0 */
  113.   0,    /* hab */
  114.   0,    /* hdc */
  115.   0,    /* hps */
  116.   ""    /* queue_name */
  117. };
  118.  
  119. /* Open the os2prn driver */
  120. private int
  121. os2prn_open(gx_device *dev)
  122. {    int code;
  123.     PTIB pptib;
  124.     PPIB pppib;
  125.     DEVOPENSTRUC dop;
  126.     ULONG cbBuf;
  127.     ULONG cbNeeded;
  128.     APIRET rc;
  129.     PBYTE pbuf;
  130.     char *p;
  131.     SIZEL sizlPage;
  132.     LONG caps[2];
  133.     HCINFO hcinfo;
  134.     LONG nforms;
  135.     float m[4];
  136.     int depth;
  137.     FILE *pfile;
  138.     int i;
  139.     char *prefix = "\\\\spool\\";  /* 8 characters long */
  140.  
  141.     PRQINFO3 *pprq;
  142.     gx_device_os2prn *oprn;
  143.  
  144.     oprn = opdev;
  145.  
  146.     if (DosGetInfoBlocks(&pptib, &pppib)) {
  147.         fprintf(stderr,"\nos2prn_open: Couldn't get pid\n");
  148.         return gs_error_limitcheck;
  149.     }
  150.     if (pppib->pib_ultype != 3) {         
  151.         /* if caller is not PM app */
  152.         fprintf(stderr,"os2prn device can only be used from a PM application\n");
  153.         return gs_error_limitcheck;
  154.     }
  155.  
  156.     opdev->hab = WinQueryAnchorBlock(hwndtext);
  157.     opdev->newframe = 0;
  158.  
  159.     if (os2prn_get_queue_list(&opdev->ql))
  160.         return gs_error_limitcheck;
  161.  
  162.     if (opdev->queue_name[0] == '\0') {
  163.         /* obtain printer name from filename */
  164.         p = opdev->fname;
  165.             for (i=0; i<8; i++) {
  166.             if (prefix[i] == '\\') {
  167.                 if ((*p != '\\') && (*p != '/'))
  168.             break;
  169.             }
  170.             else if (tolower(*p) != prefix[i])
  171.                 break;
  172.             p++;
  173.         }
  174.         if (i==8 && (strlen(p)!=0))
  175.         strcpy(opdev->queue_name, p);
  176.     }
  177.  
  178.     pprq = NULL;
  179.     if (opdev->queue_name[0] != '\0') {
  180.         for (i=0; i<opdev->ql.nqueues; i++) {
  181.         if (strcmp(opdev->ql.prq[i].pszName, opdev->queue_name) == 0) {
  182.             pprq = &(opdev->ql.prq[i]);
  183.             break;
  184.          }
  185.         }
  186.         }
  187.     else {
  188.         /* use default queue */
  189.         pprq = &(opdev->ql.prq[opdev->ql.defqueue]);
  190.     }
  191.     if (pprq == (PRQINFO3 *)NULL) {
  192.         fprintf(stderr, "Invalid os2prn queue  name -sOS2QUEUE=\042%s\042\n", opdev->queue_name);
  193.         fprintf(stderr, "Valid device names are:\n");
  194.         for (i=0; i<opdev->ql.nqueues; i++) {
  195.         fprintf(stderr, "  -sOS2QUEUE=\042%s\042\n", opdev->ql.prq[i].pszName);
  196.         }
  197.         return gs_error_rangecheck;
  198.     }
  199.  
  200.  
  201.     /* open printer device */
  202.     memset(&dop, 0, sizeof(dop));
  203.     dop.pszLogAddress = pprq->pszName;    /* queue name */
  204.     p = strchr(pprq->pszDriverName, '.');
  205.     if (p != (char *)NULL)
  206.         *p = '\0';
  207.     dop.pszDriverName = pprq->pszDriverName;
  208.     dop.pszDataType = "PM_Q_STD";
  209.     dop.pdriv = pprq->pDriverData;
  210.     opdev->hdc = DevOpenDC(opdev->hab, OD_QUEUED, "*", 9L, (PDEVOPENDATA)&dop, (HDC)NULL);
  211.     if (opdev->hdc == DEV_ERROR) {
  212.         ERRORID eid = WinGetLastError(opdev->hab);
  213.         fprintf(stderr, "DevOpenDC for printer error 0x%x\n", eid);
  214.         return gs_error_limitcheck;
  215.     }
  216.  
  217.     os2prn_free_queue_list(&opdev->ql);
  218.  
  219.     /* find out resolution of printer */
  220.     /* this is returned in pixels/metre */
  221.     DevQueryCaps(opdev->hdc, CAPS_HORIZONTAL_RESOLUTION, 2, caps);
  222.     dev->x_pixels_per_inch = (int)(caps[0] * 0.0254 + 0.5);
  223.     dev->y_pixels_per_inch = (int)(caps[1] * 0.0254 + 0.5);
  224.  
  225.     /* find out page size and margins */
  226.     /* these are returned in millimetres */
  227.     nforms = DevQueryHardcopyCaps(opdev->hdc, 0, 0, &hcinfo);
  228.     for (i=0; i<nforms; i++) {
  229.             DevQueryHardcopyCaps(opdev->hdc, i, 1, &hcinfo);
  230.         if (hcinfo.flAttributes & HCAPS_CURRENT)
  231.         break;    /* this is the default page size */
  232.     }
  233.     /* GS size is in pixels */
  234.     dev->width = hcinfo.cx * caps[0] / 1000;
  235.     dev->height = hcinfo.cy * caps[1] / 1000;
  236.     /* GS margins are in inches */
  237.     m[0] /*left*/   =  hcinfo.xLeftClip / 25.4;
  238.     m[1] /*bottom*/ =  hcinfo.yBottomClip / 25.4;
  239.     m[2] /*right*/  = (hcinfo.cx - hcinfo.xRightClip) / 25.4;
  240.     m[3] /*top*/    = (hcinfo.cy - hcinfo.yTopClip) / 25.4;
  241.     gx_device_set_margins(dev, m, true);
  242.     /* set bounding box in pixels for later drawing */
  243.     opdev->clipbox[0] = (int)(hcinfo.xLeftClip   / 25.4 * dev->x_pixels_per_inch+1); /* round inwards */
  244.     opdev->clipbox[1] = (int)(hcinfo.yBottomClip / 25.4 * dev->y_pixels_per_inch+1);
  245.     opdev->clipbox[2] = (int)(hcinfo.xRightClip  / 25.4 * dev->x_pixels_per_inch);
  246.     opdev->clipbox[3] = (int)(hcinfo.yTopClip    / 25.4 * dev->y_pixels_per_inch);
  247.  
  248.     /* get presentation space */
  249.     sizlPage.cx = dev->width;
  250.     sizlPage.cy = dev->height;
  251.     opdev->hps = GpiCreatePS(opdev->hab, opdev->hdc, &sizlPage, 
  252.         PU_PELS | GPIF_DEFAULT | GPIT_NORMAL | GPIA_ASSOC);
  253.  
  254.     depth = dev->color_info.depth;
  255.     if (depth == 0) {
  256.         /* Set parameters that were unknown before opening device */
  257.         /* Find out if the device supports color */
  258.         /* We recognize 1, 3, 8 and 24 bit color devices */
  259.         DevQueryCaps(opdev->hdc, CAPS_COLOR_PLANES, 2, caps);
  260.         /* caps[0] is #color planes, caps[1] is #bits per plane */
  261.         depth = caps[0] * caps[1];
  262.     }
  263.     os2prn_set_bpp(dev, depth);
  264.  
  265.     /* create a memory DC compatible with printer */
  266.     opdev->hdcMem = DevOpenDC(opdev->hab, OD_MEMORY, "*", 0L, NULL, opdev->hdc);
  267.     if (opdev->hdcMem == DEV_ERROR) {
  268.         ERRORID eid = WinGetLastError(opdev->hab);
  269.         fprintf(stderr, "DevOpenDC for memory error 0x%x\n", eid);
  270.         return gs_error_limitcheck;
  271.     }
  272.     sizlPage.cx = dev->width;
  273.     sizlPage.cy = dev->height;
  274.     opdev->hpsMem = GpiCreatePS(opdev->hab, opdev->hdcMem, &sizlPage, 
  275.         PU_PELS | GPIF_DEFAULT | GPIT_NORMAL | GPIA_ASSOC );
  276.     if (opdev->hpsMem == GPI_ERROR) {
  277.         ERRORID eid = WinGetLastError(opdev->hab);
  278.         fprintf(stderr, "GpiCreatePS for memory error 0x%x\n", eid);
  279.         return gs_error_limitcheck;
  280.     }
  281.  
  282.     if (DevEscape(opdev->hdc, DEVESC_STARTDOC, (LONG)strlen(gs_product), 
  283.         (char *)gs_product, NULL, NULL) == DEVESC_ERROR) {
  284.         ERRORID eid = WinGetLastError(opdev->hab);
  285.         fprintf(stderr, "DEVESC_STARTDOC error 0x%x\n", eid);
  286.         return gs_error_limitcheck;
  287.     }
  288.  
  289.     /* gdev_prn_open opens a temporary file which we don't want */
  290.     /* so we specify the name now so we can delete it later */
  291.     pfile = gp_open_scratch_file(gp_scratch_file_name_prefix, 
  292.         opdev->fname, "wb");
  293.     fclose(pfile);
  294.     code = gdev_prn_open(dev);
  295.  
  296.     return code;
  297. }
  298.  
  299. /* Close the os2prn driver */
  300. private int
  301. os2prn_close(gx_device *dev)
  302. {    int code;
  303.     LONG lOut;
  304.     USHORT usJobID;
  305.     /* tell printer that all is finished */
  306.     DevEscape(opdev->hdc, DEVESC_ENDDOC, 0L, NULL, &lOut, (PBYTE)&usJobID);
  307.     /* Free resources */
  308.     GpiAssociate(opdev->hps, (HDC)NULL);
  309.     GpiDestroyPS(opdev->hps);
  310.     DevCloseDC(opdev->hdc);
  311.  
  312.     if (opdev->hpsMem != GPI_ERROR)
  313.         GpiDestroyPS(opdev->hpsMem);
  314.     if (opdev->hdcMem != DEV_ERROR)
  315.         DevCloseDC(opdev->hdcMem);
  316.  
  317.     code = gdev_prn_close(dev);
  318.     /* delete unwanted temporary file */
  319.     unlink(opdev->fname);
  320.     return code;
  321. }
  322.  
  323. /* Get os2pm parameters */
  324. int
  325. os2prn_get_params(gx_device *dev, gs_param_list *plist)
  326. {    int code = gdev_prn_get_params(dev, plist);
  327.     gs_param_string qs;
  328.     qs.data = opdev->queue_name, qs.size = strlen(qs.data),
  329.       qs.persistent = false;
  330.     code < 0 ||
  331.     (code = param_write_string(plist, "OS2QUEUE", &qs)) < 0;
  332.     return code;
  333. }
  334.  
  335.  
  336.  
  337. /* We implement this ourselves so that we can change BitsPerPixel */
  338. /* before the device is opened */
  339. int
  340. os2prn_put_params(gx_device *dev, gs_param_list *plist)
  341. {    int ecode = 0, code;
  342.     int old_bpp = dev->color_info.depth;
  343.     int bpp = old_bpp;
  344.     gs_param_string qs;
  345.  
  346.     /* Handle extra parameters */
  347.     switch ( code = param_read_string(plist, "OS2QUEUE", &qs) )
  348.     {
  349.     case 0:
  350.         if ( qs.size == strlen(opdev->queue_name) &&
  351.              !memcmp(opdev->queue_name, qs.data, qs.size)
  352.            )
  353.           {    qs.data = 0;
  354.             break;
  355.           }
  356.         if ( dev->is_open )
  357.           ecode = gs_error_rangecheck;
  358.         else if ( qs.size >= sizeof(opdev->queue_name))
  359.           ecode = gs_error_limitcheck;
  360.         else
  361.           break;
  362.         goto qe;
  363.     default:
  364.         ecode = code;
  365. qe:        param_signal_error(plist, "OS2QUEUE", ecode);
  366.     case 1:
  367.         qs.data = 0;
  368.         break;
  369.     }
  370.  
  371.     switch ( code = param_read_int(plist, "BitsPerPixel", &bpp) )
  372.     {
  373.     case 0:
  374.         if ( dev->is_open )
  375.           ecode = gs_error_rangecheck;
  376.         else
  377.           {    /* change dev->color_info is valid before device is opened */
  378.             os2prn_set_bpp(dev, bpp);
  379.             break;
  380.           }
  381.         goto bppe;
  382.     default:
  383.         ecode = code;
  384. bppe:        param_signal_error(plist, "BitsPerPixel", ecode);
  385.     case 1:
  386.         break;
  387.     }
  388.  
  389.     if ( ecode >= 0 )
  390.         ecode = gdev_prn_put_params(dev, plist);
  391.  
  392.     if ( ( ecode >= 0 ) && ( qs.data != 0 ) )
  393.       {    memcpy(opdev->queue_name, qs.data, qs.size);
  394.         opdev->queue_name[qs.size] = 0;
  395.       }
  396.  
  397.     return ecode;
  398. }
  399.  
  400.  
  401.  
  402. /* ------ Internal routines ------ */
  403.  
  404. #undef opdev
  405. #define opdev ((gx_device_os2prn *)pdev)
  406.  
  407. /************************************************/
  408.  
  409.  
  410. /* ------ Private definitions ------ */
  411.  
  412.  
  413. /* new os2prn_print_page routine */
  414.  
  415. /* Write BMP header to memory, then send bitmap to printer */
  416. /* one scan line at a time */
  417. private int
  418. os2prn_print_page(gx_device_printer *pdev, FILE *file)
  419. {    int raster = gdev_prn_raster(pdev);
  420.     /* BMP scan lines are padded to 32 bits. */
  421.     ulong bmp_raster = (raster+3) & (~3);
  422.     ulong bmp_raster_multi;
  423.     int height = pdev->height;
  424.     int depth = pdev->color_info.depth;
  425.     byte *row;
  426.     int y;
  427.     int code = 0;            /* return code */
  428.     POINTL apts[4];
  429.     APIRET rc;
  430.     POINTL aptsb[4];
  431.     HBITMAP hbmp, hbmr;
  432.     int i, lines;
  433.     int ystart, yend;
  434.     int yslice;
  435.  
  436.     struct bmi_s {
  437.         BITMAPINFOHEADER2 h;
  438.         RGB2 pal[256];
  439.     } bmi;
  440.  
  441.     yslice = 65535 / bmp_raster;
  442.     bmp_raster_multi = bmp_raster * yslice;
  443.     row = (byte *)gs_malloc(bmp_raster_multi, 1, "bmp file buffer");
  444.     if ( row == 0 )            /* can't allocate row buffer */
  445.         return_error(gs_error_VMerror);
  446.  
  447.     if (opdev->newframe)
  448.         DevEscape(opdev->hdc, DEVESC_NEWFRAME, 0L, NULL, NULL, NULL);
  449.     opdev->newframe = 1;
  450.  
  451.     /* Write the info header. */
  452.  
  453.     memset(&bmi.h, 0, sizeof(bmi.h));
  454.     bmi.h.cbFix = sizeof(bmi.h);
  455.     bmi.h.cx = pdev->width;  /* opdev->mdev.width; */
  456.     /* bmi.h.cy = height; */
  457.     bmi.h.cy = yslice;     /* size for memory PS */
  458.     bmi.h.cPlanes = 1;
  459.     bmi.h.cBitCount = pdev->color_info.depth;
  460.  
  461.     /* Write the palette. */
  462.  
  463.     if ( depth <= 8 )
  464.     {    int i;
  465.         gx_color_value rgb[3];
  466.         PRGB2 pq;
  467.         bmi.h.cclrUsed = 1 << depth;
  468.         bmi.h.cclrImportant = 1 << depth;
  469.         for ( i = 0; i != 1 << depth; i++ )
  470.         {    (*dev_proc(pdev, map_color_rgb))((gx_device *)pdev,
  471.                 (gx_color_index)i, rgb);
  472.             pq = &bmi.pal[i];
  473.             pq->bRed   = gx_color_value_to_byte(rgb[0]);
  474.             pq->bGreen = gx_color_value_to_byte(rgb[1]);
  475.             pq->bBlue  = gx_color_value_to_byte(rgb[2]);
  476.             pq->fcOptions = 0;
  477.         }
  478.     }
  479.     else {
  480.         bmi.h.cclrUsed = 0;
  481.         bmi.h.cclrImportant = 0;
  482.     }
  483.  
  484.     /* for GpiDrawBits */
  485.     /* target is inclusive */
  486.     apts[0].x = 0;
  487.     apts[0].y = 0;  /* filled in later */
  488.     apts[1].x = pdev->width-1;
  489.     apts[1].y = 0;  /* filled in later */
  490.     /* source is not inclusive of top & right borders */
  491.     apts[2].x = 0;
  492.     apts[2].y = 0;
  493.     apts[3].x = pdev->width;
  494.     apts[3].y = 0;  /* filled in later */
  495.  
  496.     /* for GpiBitBlt */
  497.     /* target is not inclusive */
  498.     aptsb[0].x = opdev->clipbox[0];
  499.     aptsb[0].y = 0;  /* filled in later */
  500.     aptsb[1].x = opdev->clipbox[2];
  501.     aptsb[1].y = 0;  /* filled in later */
  502.     /* source is not inclusive */
  503.     aptsb[2].x = opdev->clipbox[0];
  504.     aptsb[2].y = 0;
  505.     aptsb[3].x = opdev->clipbox[2];
  506.     aptsb[3].y = 0;     /* filled in later */
  507.  
  508.     /* write the bits */
  509.     ystart = opdev->clipbox[3];
  510.     yend = opdev->clipbox[1];
  511.     y = ystart;
  512.     while (y > yend) {
  513.         /* create a bitmap for the memory DC */
  514.         hbmp = GpiCreateBitmap(opdev->hpsMem, &bmi.h, 0L, NULL, NULL);
  515.         if (hbmp == GPI_ERROR)
  516.            goto bmp_done;
  517.         hbmr = GpiSetBitmap(opdev->hpsMem, hbmp);
  518.  
  519.         /* copy slice to memory bitmap */
  520.         if (y > yend + yslice)
  521.         lines = yslice;
  522.         else
  523.         lines = y - yend;
  524.         y -= lines;
  525.         for (i=lines-1; i>=0; i--)
  526.             gdev_prn_copy_scan_lines(pdev, ystart-1 - (y+i), row + (bmp_raster*i), raster);
  527.         apts[0].y = 0;        /* target */
  528.         apts[1].y = lines;
  529.         apts[3].y = lines-1;    /* source */
  530.         /* copy DIB bitmap to memory bitmap */
  531.         rc = GpiDrawBits(opdev->hpsMem, row, (BITMAPINFO2 *)&bmi, 4, apts, 
  532.         (depth != 1) ? ROP_SRCCOPY : ROP_NOTSRCCOPY, 0);
  533.  
  534.         /* copy slice to printer */
  535.         aptsb[0].y = y;
  536.         aptsb[1].y = y+lines;
  537.         aptsb[3].y = lines;
  538.         rc = GpiBitBlt(opdev->hps, opdev->hpsMem, 4, aptsb, ROP_SRCCOPY, BBO_IGNORE);
  539.  
  540.         /* delete bitmap */
  541.         if (hbmr != HBM_ERROR)
  542.             GpiSetBitmap(opdev->hpsMem, (ULONG)0);
  543.         hbmr = HBM_ERROR;
  544.         if (hbmp != GPI_ERROR)
  545.             GpiDeleteBitmap(hbmp);
  546.         hbmp = GPI_ERROR;
  547.     }
  548.  
  549. bmp_done:
  550.     if (row)
  551.         gs_free((char *)row, bmp_raster_multi, 1, "bmp file buffer");
  552.  
  553.     return code;
  554. }
  555.  
  556. /* combined color mappers */
  557.  
  558. /* 24-bit color mappers (taken from gdevmem2.c). */
  559. /* Note that OS/2 expects RGB values in the order B,G,R. */
  560.  
  561. /* Map a r-g-b color to a color index. */
  562. private gx_color_index
  563. os2prn_map_rgb_color(gx_device *dev, gx_color_value r, gx_color_value g,
  564.   gx_color_value b)
  565. {
  566.     switch(dev->color_info.depth) {
  567.       case 1:
  568.     return gdev_prn_map_rgb_color(dev, r, g, b);
  569.       case 4:
  570.     /* use only 8 colors */
  571.     return  (r > (gx_max_color_value / 2 + 1) ? 4 : 0) +
  572.              (g > (gx_max_color_value / 2 + 1) ? 2 : 0) +
  573.              (b > (gx_max_color_value / 2 + 1) ? 1 : 0) ;
  574.       case 8:
  575.     return pc_8bit_map_rgb_color(dev, r, g, b);
  576.       case 24:
  577.     return gx_color_value_to_byte(r) +
  578.            ((uint)gx_color_value_to_byte(g) << 8) +
  579.            ((ulong)gx_color_value_to_byte(b) << 16);
  580.     }
  581.     return 0; /* error */
  582. }
  583.  
  584. /* Map a color index to a r-g-b color. */
  585. private int
  586. os2prn_map_color_rgb(gx_device *dev, gx_color_index color,
  587.   gx_color_value prgb[3])
  588. {
  589.     switch(dev->color_info.depth) {
  590.       case 1:
  591.     gdev_prn_map_color_rgb(dev, color, prgb);
  592.     break;
  593.       case 4:
  594.     /* use only 8 colors */
  595.     prgb[0] = (color & 4) ? gx_max_color_value : 0;
  596.     prgb[1] = (color & 2) ? gx_max_color_value : 0;
  597.     prgb[2] = (color & 1) ? gx_max_color_value : 0;
  598.     break;
  599.       case 8:
  600.     pc_8bit_map_color_rgb(dev, color, prgb);
  601.     break;
  602.       case 24:
  603.     prgb[2] = gx_color_value_from_byte(color >> 16);
  604.     prgb[1] = gx_color_value_from_byte((color >> 8) & 0xff);
  605.     prgb[0] = gx_color_value_from_byte(color & 0xff);
  606.     break;
  607.     }
  608.     return 0;
  609. }
  610.  
  611. void
  612. os2prn_set_bpp(gx_device *dev, int depth)
  613. {
  614.     if (depth > 8) {
  615.         static const gx_device_color_info os2prn_24color = dci_std_color(24);
  616.         dev->color_info = os2prn_24color;
  617.     }
  618.     else if ( depth >= 8 ) {
  619.         /* 8-bit (SuperVGA-style) color. */
  620.         /* (Uses a fixed palette of 3,3,2 bits.) */
  621.         static const gx_device_color_info os2prn_8color = dci_pc_8bit;
  622.         dev->color_info = os2prn_8color;
  623.     }
  624.     else if ( depth >= 3) {
  625.         /* 3 plane printer */
  626.         /* suitable for impact dot matrix CMYK printers */
  627.         /* create 4-bit bitmap, but only use 8 colors */
  628.         static const gx_device_color_info os2prn_4color = {3, 4, 1, 1, 2, 2};
  629.         dev->color_info = os2prn_4color;
  630.     }
  631.     else {   /* default is black_and_white */
  632.         static const gx_device_color_info os2prn_1color = dci_std_color(1);
  633.         dev->color_info = os2prn_1color;
  634.     }
  635. }
  636.  
  637. /* Get list of queues from SplEnumQueue */
  638. /* returns 0 if OK, non-zero for error */
  639. private int
  640. os2prn_get_queue_list(OS2QL *ql)
  641. {
  642.     SPLERR splerr;
  643.     USHORT jobCount;
  644.     ULONG  cbBuf;
  645.     ULONG  cTotal;
  646.     ULONG  cReturned;
  647.     ULONG  cbNeeded;
  648.     ULONG  ulLevel;
  649.     ULONG  i;
  650.     PSZ    pszComputerName;
  651.     PBYTE  pBuf;
  652.     PPRQINFO3 prq;
  653.  
  654.     ulLevel = 3L;
  655.     pszComputerName = (PSZ)NULL ;
  656.     splerr = SplEnumQueue(pszComputerName, ulLevel, pBuf, 0L, /* cbBuf */
  657.                           &cReturned, &cTotal,
  658.                           &cbNeeded, NULL);
  659.     if ( splerr == ERROR_MORE_DATA || splerr == NERR_BufTooSmall ) {
  660.     pBuf = gs_malloc(cbNeeded, 1, "OS/2 printer device info buffer");
  661.     ql->prq = (PRQINFO3 *)pBuf;
  662.     if (ql->prq != (PRQINFO3 *)NULL) {
  663.       ql->len = cbNeeded;
  664.           cbBuf = cbNeeded ;
  665.           splerr = SplEnumQueue(pszComputerName, ulLevel, pBuf, cbBuf,
  666.                                   &cReturned, &cTotal,
  667.                                   &cbNeeded, NULL);
  668.           if (splerr == NO_ERROR) {
  669.              /* Set pointer to point to the beginning of the buffer.           */
  670.              prq = (PPRQINFO3)pBuf ;
  671.              /* cReturned has the count of the number of PRQINFO3 structures.  */
  672.          ql->nqueues = cReturned;
  673.          ql->defqueue = 0;
  674.              for (i=0;i < cReturned ; i++) {
  675.         if ( prq->fsType & PRQ3_TYPE_APPDEFAULT )
  676.              ql->defqueue = i;
  677.                 prq++;
  678.              }/*endfor cReturned */
  679.           }
  680.        }
  681.     } 
  682.     else {
  683.        /* If we are here we had a bad error code. Print it and some other info.*/
  684.        fprintf(stdout, "SplEnumQueue Error=%ld, Total=%ld, Returned=%ld, Needed=%ld\n",
  685.                splerr, cTotal, cReturned, cbNeeded) ;
  686.     }
  687.     if (splerr)
  688.         return splerr;
  689.     return 0;
  690. }
  691.  
  692.  
  693. private void
  694. os2prn_free_queue_list(OS2QL *ql)
  695. {
  696.     gs_free((char *)ql->prq, ql->len, 1, "os2prn queue list");
  697.     ql->prq = NULL;
  698.     ql->len = 0;
  699.     ql->defqueue = 0;
  700.     ql->nqueues = 0;
  701. }
  702.